home *** CD-ROM | disk | FTP | other *** search
/ Unreal Tournament Game Programming for Teens / UnrealTournamentGameProgrammingForTeens.iso / Chapter Files / Chapter07 / PostBeginPlay-Touch.txt < prev    next >
Encoding:
Text File  |  2006-10-17  |  3.9 KB  |  80 lines
  1.  
  2. At the highest level in the Actor class hierarcy is the Actor class. In this class, functions are defined in several ways. A function can be considered so characteristic of given object that the object should always be created with the behavior the function defines. This is one purpose of the event keyword. It allows programmers to establish a function as an event a primary characteristic of the object it is associated with. For this reason, in the definition of the Actor class, you find the PostBeginPlay() function identified as an event. Both functions here appear without reference to any previous versions. The defitions you see here constitute the primary definitions of the functions. When you see a function declared in this way, the function constitutes an abstract function. An abstruct function is a function that has not content. Notice, for example, that the two functions lack blocks. There is no code associated with them. They are declared so that you know their return types and the arguments they take, but what they do remains to be seen.
  3.  
  4. //As defined in the Actor class
  5. event PostBeginPlay();
  6.  
  7. event Touch( Actor Other );
  8.  
  9.  
  10. The Trigger class is derived from the Actor class. When you derive one class from another, as has been mentioned before, if the functions in the base class are defined with public access, then you can calll them them in the classes you derive from them. In the Actor class, you see no access modifiers in the defintion of the PostmBeginPlay()and SetInitialState() functions, so they are in this respect implicitly defined as public functions. As publich functions, they can be readily accessed in the Trigger class.
  11.  
  12. In this case, the situation differs from those you are likely to encounter when you define your functions, for the functions in the parent class are abstract. The Trigger class provides a context in which to define them. Here are the defitions as they appear in the Trigger class:
  13.  
  14. //As defined in the Trigger class
  15.  
  16. function PostBeginPlay()
  17. {
  18.     if ( !bInitiallyActive )
  19.         FindTriggerActor();
  20.     if ( TriggerType == TT_Shoot )
  21.     {
  22.         bHidden = false;
  23.         bProjTarget = true;
  24.         SetDrawType(DT_None);
  25.     }
  26.     bSavedInitialActive = bInitiallyActive;
  27.     bSavedInitialCollision = bCollideActors;
  28.     Super.PostBeginPlay();
  29. }
  30.  
  31.  
  32. //As defined in the Trigger class
  33.  
  34. function Touch( actor Other )
  35. {
  36.     local int i;
  37.  
  38.     if( IsRelevant( Other ) )
  39.     {
  40.         Other = FindInstigator( Other );
  41.  
  42.         if ( ReTriggerDelay > 0 )
  43.         {
  44.             if ( Level.TimeSeconds - TriggerTime < ReTriggerDelay )
  45.                 return;
  46.             TriggerTime = Level.TimeSeconds;
  47.         }
  48.         // Broadcast the Trigger message to all matching actors.
  49.         TriggerEvent(Event, self, Other.Instigator);
  50.  
  51.         if ( (Pawn(Other) != None) && (Pawn(Other).Controller != None) )
  52.         {
  53.             for ( i=0; i<4; i++ )
  54.                 if ( Pawn(Other).Controller.GoalList[i] == self )
  55.                 {
  56.                     Pawn(Other).Controller.GoalList[i] = None;
  57.                     break;
  58.                 }
  59.         }    
  60.                 
  61.         if( (Message != "") && (Other.Instigator != None) )
  62.             // Send a string message to the toucher.
  63.             Other.Instigator.ClientMessage( Message );
  64.  
  65.         if( bTriggerOnceOnly )
  66.             // Ignore future touches.
  67.             SetCollision(False);
  68.         else if ( RepeatTriggerTime > 0 )
  69.             SetTimer(RepeatTriggerTime, false);
  70.     }
  71. }
  72.  
  73. In the Trigger class, you see two things. First, the signature lines of the functions are restated with the keyword function but in other resepcts, they remain the same as those that appear in the base class. Using the function keyword rather than the event keyword indicates that in this case they are to be defined. In other words, code is to be added to them that gives them functionality. To add the code, opening and closing curely braces are add, an statments then appear in the function block the braces create.
  74.  
  75. A second feature is that in the redefintion of the PostBegin() play method, you see a call to the Super.PostBeginPlay() function. . When you define a function, you provide it with a content. 
  76.  
  77.  
  78.  
  79.  
  80.